package com.haohan.jingyuan.customer.helper;

import com.haohan.jingyuan.customer.dto.resp.VisitorFileInfoResp;
import com.haohan.jingyuan.customer.entity.CustomerFile;
import com.haohan.jingyuan.customer.entity.CustomerGroupInfo;
import com.haohan.jingyuan.customer.entity.CustomerTag;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 访客文件响应对象转换工具类
 *
 * @ClassName VisitorFileRespHelper
 * @Description 访客文件响应对象转换工具，支持构建分组层级结构
 * @Author hexijun
 * @Time 2025/11/05 15:00
 * @Version 1.0
 */
public class VisitorFileRespHelper {

    /**
     * 将文件列表转换为层级结构的响应对象列表
     *
     * @param customerFiles 文件列表
     * @param groupMap 分组信息Map，key为groupId，value为CustomerGroupInfo
     * @return 层级结构的文件响应对象列表
     */
    public static List<VisitorFileInfoResp> convert2VisitorFileInfoRespList(
            List<CustomerFile> customerFiles, Map<String, CustomerGroupInfo> groupMap) {
        return convert2VisitorFileInfoRespList(customerFiles, groupMap, null);
    }

    /**
     * 将文件列表转换为层级结构的响应对象列表（带标签信息）
     *
     * @param customerFiles 文件列表
     * @param groupMap 分组信息Map，key为groupId，value为CustomerGroupInfo
     * @param tagMap 标签信息Map，key为tagCode，value为CustomerTag
     * @return 层级结构的文件响应对象列表
     */
    public static List<VisitorFileInfoResp> convert2VisitorFileInfoRespList(
            List<CustomerFile> customerFiles, Map<String, CustomerGroupInfo> groupMap, Map<String, CustomerTag> tagMap) {
        if (CollectionUtils.isEmpty(customerFiles)) {
            return new ArrayList<>();
        }

        // 构建分组层级的Map：key为parentGroupId，value为该分组下的文件列表
        Map<String, List<VisitorFileInfoResp>> groupFileMap = new HashMap<>();
        // 存储所有文件节点（包括分组节点和文件节点）
        Map<String, VisitorFileInfoResp> allNodeMap = new HashMap<>();

        // 第一步：转换文件并按照groupCode分组
        for (CustomerFile customerFile : customerFiles) {
            VisitorFileInfoResp fileResp = convert2VisitorFileInfoResp(customerFile, groupMap, tagMap);
            
            String groupCode = customerFile.getGroupCode();
            if (groupCode == null || groupCode.trim().isEmpty()) {
                groupCode = "ROOT";
            }
            
            groupFileMap.computeIfAbsent(groupCode, k -> new ArrayList<>()).add(fileResp);
        }

        // 第二步：构建分组层级结构
        // 先处理所有分组节点
        for (Map.Entry<String, CustomerGroupInfo> entry : groupMap.entrySet()) {
            String groupId = entry.getKey();
            CustomerGroupInfo groupInfo = entry.getValue();
            
            // 如果该分组下有文件，创建分组节点
            if (groupFileMap.containsKey(groupId)) {
                VisitorFileInfoResp groupNode = new VisitorFileInfoResp();
                groupNode.setGroupCode(groupId);
                groupNode.setGroupName(groupInfo.getGroupName());
                groupNode.setChildren(new ArrayList<>());
                allNodeMap.put(groupId, groupNode);
            }
        }

        // 第三步：将文件添加到对应的分组节点
        for (Map.Entry<String, List<VisitorFileInfoResp>> entry : groupFileMap.entrySet()) {
            String groupCode = entry.getKey();
            List<VisitorFileInfoResp> files = entry.getValue();
            
            if ("ROOT".equals(groupCode)) {
                // 没有分组的文件，直接添加到根节点
                if (!allNodeMap.containsKey("ROOT")) {
                    VisitorFileInfoResp rootNode = new VisitorFileInfoResp();
                    rootNode.setGroupCode("ROOT");
                    rootNode.setGroupName("未分组");
                    rootNode.setChildren(new ArrayList<>());
                    allNodeMap.put("ROOT", rootNode);
                }
                allNodeMap.get("ROOT").getChildren().addAll(files);
            } else {
                // 有分组的文件，添加到对应的分组节点
                if (allNodeMap.containsKey(groupCode)) {
                    allNodeMap.get(groupCode).getChildren().addAll(files);
                }
            }
        }

        // 第四步：构建父子关系
        List<VisitorFileInfoResp> rootList = new ArrayList<>();
        for (Map.Entry<String, VisitorFileInfoResp> entry : allNodeMap.entrySet()) {
            String groupId = entry.getKey();
            VisitorFileInfoResp node = entry.getValue();
            
            if ("ROOT".equals(groupId)) {
                // 根节点直接添加到结果列表
                rootList.add(node);
            } else {
                CustomerGroupInfo groupInfo = groupMap.get(groupId);
                if (groupInfo != null) {
                    String parentGroupId = groupInfo.getParentGroupId();
                    if (parentGroupId == null || parentGroupId.trim().isEmpty()) {
                        // 没有父分组，作为根节点
                        rootList.add(node);
                    } else {
                        // 有父分组，添加到父分组
                        if (allNodeMap.containsKey(parentGroupId)) {
                            allNodeMap.get(parentGroupId).getChildren().add(node);
                        } else {
                            // 父分组不存在，作为根节点
                            rootList.add(node);
                        }
                    }
                } else {
                    // 分组信息不存在，作为根节点
                    rootList.add(node);
                }
            }
        }

        return rootList;
    }

    /**
     * 将文件实体转换为文件响应对象
     *
     * @param customerFile 文件实体
     * @param groupMap 分组信息Map
     * @param tagMap 标签信息Map
     * @return 文件响应对象
     */
    private static VisitorFileInfoResp convert2VisitorFileInfoResp(
            CustomerFile customerFile, Map<String, CustomerGroupInfo> groupMap, Map<String, CustomerTag> tagMap) {
        if (customerFile == null) {
            return null;
        }

        VisitorFileInfoResp fileResp = new VisitorFileInfoResp();
        fileResp.setFileKey(customerFile.getFileKey());
        fileResp.setFileType(customerFile.getFileType());
        fileResp.setSignAt(customerFile.getSignAt());
        fileResp.setExpireAt(customerFile.getExpireAt());
        fileResp.setGroupCode(customerFile.getGroupCode());
        fileResp.setTag(customerFile.getTag());
        
        // 设置分组名称
        if (customerFile.getGroupCode() != null && !customerFile.getGroupCode().trim().isEmpty()) {
            CustomerGroupInfo groupInfo = groupMap != null ? groupMap.get(customerFile.getGroupCode()) : null;
            if (groupInfo != null) {
                fileResp.setGroupName(groupInfo.getGroupName());
            }
        }

        // 设置标签名称（支持多个标签，逗号分隔）
        if (customerFile.getTag() != null && !customerFile.getTag().trim().isEmpty()) {
            if (tagMap != null) {
                String[] tagCodes = customerFile.getTag().split(",");
                Set<String> tagNames = Stream.of(tagCodes)
                        .map(String::trim)
                        .filter(code -> !code.isEmpty())
                        .map(code -> tagMap.get(code))
                        .filter(tag -> tag != null)
                        .map(CustomerTag::getTagName)
                        .collect(Collectors.toSet());
                if (!tagNames.isEmpty()) {
                    fileResp.setTagName(String.join(",", tagNames));
                }
            }
        }

        return fileResp;
    }
}

